home *** CD-ROM | disk | FTP | other *** search
/ The Utilities Experience / The Utilities Experience - Volume 1.iso / software / graphics / gfx_card / egsgowgah / egsgowgah.c < prev    next >
C/C++ Source or Header  |  1995-12-21  |  18KB  |  861 lines
  1.  
  2. /*
  3.     blip.c - or also called 'EGSUliGauge' ("Gow-Gah" !)
  4.     Nothing serious. Really, in fact useless. Nevertheless - cute. :-)
  5.  
  6.     This program is published under the S.U.C.K.S. label
  7.     Initially triggered by Matthias 'DrMabuse' Luehr in de.comp.sys.amiga.misc (?)
  8.  
  9.     Frank Neumann, October 1994
  10. */
  11.  
  12. #include <stdio.h>
  13. #include <stdlib.h>
  14. #include <string.h>
  15. #include <time.h>
  16. #include <exec/types.h>
  17. #include <clib/exec_protos.h>
  18. #include <clib/dos_protos.h>
  19.  
  20. #include <egs/egs.h>
  21. #include <egs/egsintui.h>
  22. #include <egs/egsgfx.h>
  23. #include <egs/clib/egs_protos.h>
  24. #include <egs/clib/egsintui_protos.h>
  25. #include <egs/clib/egsgfx_protos.h>
  26.  
  27. /* include image maps */
  28. #include "img/n1.h"
  29. #include "img/n2.h"
  30. #include "img/n3.h"
  31. #include "img/n4.h"
  32. #include "img/n5.h"
  33. #include "img/n6.h"
  34. #include "img/n7.h"
  35. #include "img/n8.h"
  36. #include "img/design.h"
  37. #include "img/flame.h"
  38. #include "img/sun.h"
  39. #include "img/egs.h"
  40. #include "img/fish.h"
  41. #include "img/franky.h"
  42. #include "img/mountain.h"
  43. #include "img/steffi.h"
  44.  
  45.  
  46. /* defines */
  47. #define WIDTH   256
  48. #define HEIGHT  128
  49. #define FALSE 0
  50. #define TRUE  1
  51.  
  52. #define IMG_WIDTH    30
  53. #define IMG_HEIGHT    30
  54.  
  55. #define GRAY 0x50505000
  56.  
  57. /* global variables */
  58. /* yes, there are already too much of these by now.. *sigh* */
  59. struct Library        *EGSIntuiBase   = NULL;
  60. struct Library        *EGSBase        = NULL;
  61. struct Library        *EGSGfxBase     = NULL;
  62.  
  63. struct EI_NewWindow my_newwindow;
  64. EI_WindowPtr         my_window;
  65. EI_EIntuiMsgPtr        msg;
  66. E_EGSClassPtr        mapclass = NULL;
  67. E_EBitMapPtr        pixmaps[8] = NULL;
  68.  
  69.  
  70. /* version information */
  71. static char *vers = "$VER: EGSGowgah 0.1pre (27.10.94)";
  72.  
  73. /* prototypes */
  74. void          main( int, char *[] );
  75. void          draw_randblink( int x, int y, EG_RastPortPtr rp );
  76. void          draw_bincount( int x, int y, EG_RastPortPtr rp );
  77. void          draw_enterprise( int x, int y, EG_RastPortPtr rp );
  78. void          draw_activity( int x, int y, EG_RastPortPtr rp, unsigned long col, int ind, int del );
  79. void          draw_zip( int x, int y, EG_RastPortPtr rp, int ind );
  80. void          draw_bars( int x, int y, EG_RastPortPtr rp, int ind );
  81. void          draw_vbars( int x, int y, EG_RastPortPtr rp, int ind );
  82. void          draw_ekg( int x, int y, EG_RastPortPtr rp, int ind );
  83. void          draw_pix( int x, int y, EG_RastPortPtr rp );
  84. void          crash(char * string);
  85.  
  86. /*******************************************/
  87. /* entry point when started from Workbench */
  88. /*******************************************/
  89. int wbmain(struct WBStartup *wbs)
  90. {
  91.     return(main(0, (char **)wbs));
  92. }
  93.  
  94.  
  95. /********************/
  96. /*** main function **/
  97. /********************/
  98. void main(int argc, char *argv[])
  99. {
  100.     int i, flag = 0;
  101.     int done = FALSE;
  102.     E_Symbol mapsymbol;
  103.     unsigned long *maps[16] =
  104.     {
  105.         noise1_image,
  106.         noise2_image,
  107.         noise3_image,
  108.         noise4_image,
  109.         noise5_image,
  110.         noise6_image,
  111.         noise7_image,
  112.         noise8_image,
  113.         design_image,
  114.         egs_image,
  115.         sun_image,
  116.         flame_image,
  117.         fish_image,
  118.         franky_image,
  119.         mountain_image,
  120.         steffi_image
  121.     };
  122.  
  123.     srand(time(NULL));
  124.  
  125.     /* be nice.. */
  126.     SetTaskPri(FindTask(0), -1);
  127.  
  128.     /* open required libraries */
  129.     EGSBase = (APTR)OpenLibrary("egs.library", 5L);
  130.     if (EGSBase == NULL)
  131.         crash("Could not open egs.library");
  132.  
  133.     EGSIntuiBase = (APTR)OpenLibrary("egsintui.library", 6L);
  134.     if (EGSIntuiBase == NULL)
  135.         crash("Could not open egsintui.library");
  136.  
  137.     EGSGfxBase = (APTR)OpenLibrary("egsgfx.library", 6L);
  138.     if (EGSGfxBase == NULL)
  139.         crash("Could not open egsgfx.library");
  140.  
  141.     /* get the symbol name of the 24 bit chunkymap class */
  142.     mapsymbol  = E_GetSymbol("ChunkyMap24.class");
  143.  
  144.     /* obtain public class of that symbol - that is, load and init the */
  145.     /* class if this has not already been done */
  146.     mapclass = E_ObtainPublicClass(mapsymbol);
  147.  
  148.     if (mapclass == NULL)
  149.         crash("could not obtain public class for chunkymap24");
  150.  
  151.     /* Create the pixmaps for images */
  152.     for (i = 0; i < 16; i++)
  153.     {
  154.         pixmaps[i] = E_AllocBitMapFrame(mapclass, IMG_WIDTH, IMG_HEIGHT, 0);
  155.         if (pixmaps[i] == NULL)
  156.             crash("could not alloc bitmap frame");
  157.  
  158.         pixmaps[i]->Plane = maps[i];
  159.         pixmaps[i]->BytesPerRow = 4 * IMG_WIDTH;
  160.     }
  161.  
  162.     my_newwindow.LeftEdge = 20;
  163.     my_newwindow.TopEdge  = 20;
  164.     my_newwindow.Width    = WIDTH;
  165.     my_newwindow.Height   = HEIGHT;
  166.     my_newwindow.MinWidth = WIDTH;
  167.     my_newwindow.MinHeight= HEIGHT;
  168.     my_newwindow.MaxWidth = WIDTH;
  169.     my_newwindow.MaxHeight= HEIGHT;
  170.     my_newwindow.Screen   = NULL;
  171.     my_newwindow.Bordef.SysGadgets =  EI_WINDOWCLOSE | EI_WINDOWFRONT | EI_WINDOWDRAG;
  172.     my_newwindow.FirstGadgets  = NULL;
  173.     my_newwindow.Title     = "EGSGowgah by Franky (S.U.C.K.S.)",
  174.     my_newwindow.Flags    = EI_SMART_REFRESH | EI_GIMMEZEROZERO;
  175.     my_newwindow.IDCMPFlags = EI_iCLOSEWINDOW;
  176.     my_newwindow.Port     = NULL;
  177.     my_newwindow.Menu     = NULL;
  178.     my_newwindow.Render   = NULL;
  179.  
  180.     my_window = EI_OpenWindow(&my_newwindow);
  181.     if (my_window == NULL)
  182.         crash("could not open window.");
  183.  
  184.     EG_SetAPen(my_window->RPort, 0);
  185.     EG_RectFill(my_window->RPort, 0, 0, WIDTH, HEIGHT);
  186.  
  187.     /* loop until we get an EI_iWINDOWCLOSE message */
  188.     while (!done)
  189.     {
  190. /*        WaitPort(my_window->UserPort); */
  191.         if (msg = (EI_EIntuiMsgPtr)GetMsg(my_window->UserPort))
  192.         {
  193.             switch (msg->Class)
  194.             {
  195.                 case EI_iCLOSEWINDOW:
  196.                     ReplyMsg((struct Message *)msg);
  197.                     done = TRUE;
  198.                     break;
  199.  
  200.                 default:
  201.                     printf(" Unknown message %ld\n", msg->Class);
  202.                     ReplyMsg((struct Message *)msg);
  203.             }
  204.         }
  205.  
  206.         /* do the drawing... */
  207.         Delay(1);
  208.  
  209.         draw_randblink(10, 20, my_window->RPort);
  210.         draw_bincount(90, 20, my_window->RPort);
  211.         draw_enterprise(86, 40, my_window->RPort);
  212.         draw_activity( 90, 54, my_window->RPort, 0xffd00000, 0, 4);
  213.         draw_activity( 90, 72, my_window->RPort, 0x00ff0000, 1, 10);
  214.         draw_activity(110, 54, my_window->RPort, 0x80ff4000, 2, 20);
  215.         draw_activity(110, 72, my_window->RPort, 0xe0ff0000, 3, 12);
  216.  
  217.         draw_ekg(124, 48, my_window->RPort, 0);
  218.  
  219.         draw_zip(2, 120, my_window->RPort, 0);
  220.         draw_zip(2,   6, my_window->RPort, 1);
  221.         draw_bars(4,  88, my_window->RPort, 0);
  222.         draw_bars(4,  98, my_window->RPort, 1);
  223.         draw_bars(4, 108, my_window->RPort, 2);
  224.  
  225.         draw_vbars(210, 13, my_window->RPort, 0);
  226.         draw_vbars(220, 13, my_window->RPort, 1);
  227.         draw_vbars(230, 13, my_window->RPort, 2);
  228.         draw_vbars(240, 13, my_window->RPort, 3);
  229.  
  230.         draw_pix(164, 48, my_window->RPort);
  231.     }
  232.  
  233.     crash(NULL);
  234. }
  235.  
  236. /********************/
  237. /* draw_randblink() */
  238. /********************/
  239.  
  240. void draw_randblink(int x, int y, EG_RastPortPtr rp)
  241. {
  242.     static int been_here = FALSE;
  243.     int i, j, xp, yp;
  244.     long r, g, b, col;
  245.  
  246.     if (been_here == FALSE)
  247.     {
  248.         been_here = TRUE;
  249.  
  250.         for (i = 0; i < 8; i++)
  251.         {
  252.             for (j = 0; j < 8; j++)
  253.             {
  254.                 EG_SetAPen(rp, GRAY);
  255.                 EG_Move(rp, x + i * 8, y + j * 8);
  256.                 EG_Draw(rp, x + i * 8 + 5 , y + j * 8);
  257.                 EG_Draw(rp, x + i * 8 + 5 , y + j * 8 + 5);
  258.                 EG_Draw(rp, x + i * 8, y + j * 8 + 5);
  259.                 EG_Draw(rp, x + i * 8, y + j * 8);
  260.             }
  261.         }
  262.     }
  263.  
  264.     xp = rand() % 8;
  265.     yp = rand() % 8;
  266.  
  267.     r = rand() % 255;
  268.     g = rand() % 255;
  269.     b = rand() % 255;
  270.     col = r << 24 | g << 16 | b << 8;
  271.  
  272.     if (rand() % 2 == 1)
  273.     {
  274.         if (rand() % 100 == 42)
  275.             EG_SetAPen(rp, 0xff200000);
  276.         else
  277.             EG_SetAPen(rp, 0xffd00000);
  278.  
  279.         EG_RectFill(rp, x + xp * 8 + 1, y + yp * 8 + 1, 4, 4);
  280.     }
  281.     else
  282.     {
  283.         EG_SetAPen(rp, 0x00000000);
  284.         EG_RectFill(rp, x + xp * 8 + 1, y + yp * 8 + 1, 4, 4);
  285.     }
  286. }
  287.  
  288. /*****************/
  289. /* draw_bincount */
  290. /*****************/
  291.  
  292. void draw_bincount(int x, int y, EG_RastPortPtr rp)
  293. {
  294.     static int been_here = FALSE;
  295.     static unsigned char val = 0;
  296.     static int cnt2 = 0;
  297.     int r, g;
  298.     int i, cnt;
  299.  
  300.     if (been_here == FALSE)
  301.     {
  302.         been_here = TRUE;
  303.  
  304.         for (i = 0; i < 8; i++)
  305.         {
  306.             EG_SetAPen(rp, GRAY);
  307.             EG_Move(rp, x + i * 12 + 1, y);
  308.             EG_Draw(rp, x + i * 12 + 8 , y);
  309.  
  310.             EG_Move(rp, x + i * 12 + 9, y + 1);
  311.             EG_Draw(rp, x + i * 12 + 9, y + 8);
  312.  
  313.             EG_Move(rp, x + i * 12 + 8, y + 9);
  314.             EG_Draw(rp, x + i * 12 + 1, y + 9);
  315.  
  316.             EG_Move(rp, x + i * 12, y + 8);
  317.             EG_Draw(rp, x + i * 12, y + 1);
  318.         }
  319.     }
  320.  
  321.     cnt2++;
  322.     if (cnt2 == 4)
  323.     {
  324.         cnt2 = 0;
  325.  
  326.         val++;
  327.         if (val == 256)
  328.             val = 0;
  329.  
  330.         cnt = 7;
  331.         for (i = 1; i < 256; i = i << 1)
  332.         {
  333.             if (val & i)
  334.             {
  335.                 if (rand() % 256 == 42)
  336.                     EG_SetAPen(rp, 0xff200000);
  337.                 else
  338.                 {
  339.                     if (val > 192)
  340.                     {
  341.                         r = 0x00 + ((val - 192) * 3);
  342.                         g = 0xff - ((val - 192) * 3);
  343.                         EG_SetAPen(rp, r << 24 | g << 16);
  344.                     }
  345.                     else
  346.                         EG_SetAPen(rp, 0x00ff0000);
  347.                 }
  348.  
  349.                 EG_RectFill(rp, x + cnt * 12 + 1, y + 1, 8, 8);
  350.             }
  351.             else
  352.                {
  353.                 EG_SetAPen(rp, 0x00000000);
  354.                 EG_RectFill(rp, x + cnt * 12 + 1, y + 1, 8, 8);
  355.             }
  356.             cnt--;
  357.         }
  358.     }
  359. }
  360.  
  361.  
  362. /*******************/
  363. /* draw_enterprise */
  364. /*******************/
  365. void draw_enterprise(int x, int y, EG_RastPortPtr rp)
  366. {
  367.     static int been_here = FALSE;
  368.     static unsigned char val = 0, oldval = -1;
  369.     static int cnt2 = 0;
  370.     unsigned char r, g, b;
  371.     unsigned long col;
  372.     int i;
  373.  
  374.     if (been_here == FALSE)
  375.     {
  376.         been_here = TRUE;
  377.  
  378.         for (i = 0; i < 11; i++)
  379.         {
  380.             EG_SetAPen(rp, GRAY);
  381.             EG_RectFill(rp, x + i * 10, y, 6, 2);
  382.         }
  383.      }
  384.  
  385.     cnt2++;
  386.     if (cnt2 == 3)
  387.     {
  388.         cnt2 = 0;
  389.  
  390.         if (oldval != -1)
  391.         {
  392.             EG_SetAPen(rp, GRAY);
  393.             EG_RectFill(rp, x + oldval * 10, y, 6, 2);
  394.             EG_RectFill(rp, x + (10 - oldval) * 10, y, 6, 2);
  395.         }
  396.         if (val < 5)
  397.         {
  398.             EG_SetAPen(rp, 0xffd00000);
  399.             EG_RectFill(rp, x + val * 10, y, 6, 2);
  400.             EG_RectFill(rp, x + (10 - val) * 10, y, 6, 2);
  401.         }
  402.         else
  403.         {
  404.             r = 0x30 + (9 - val) * 32;
  405.             g = 0x30 + (9 - val) * 32;
  406.             b = 0x30 + (9 - val) * 32;
  407.             col = r << 24 | g << 16 | b << 8;
  408.  
  409.             EG_SetAPen(rp, col);
  410.             EG_RectFill(rp, x + 5 * 10, y, 6, 2);
  411.         }
  412.  
  413.         val++;
  414.         if (val > 5)
  415.         {
  416.             oldval = -1;
  417.             if (val == 10)
  418.                 val = 0;
  419.         }
  420.         else
  421.             oldval = val - 1;
  422.  
  423.     }
  424. }
  425.  
  426.  
  427. /*****************/
  428. /* draw_activity */
  429. /*****************/
  430. void draw_activity(int x, int y, EG_RastPortPtr rp, unsigned long col, int ind, int del)
  431. {
  432.     static int been_here[10] = FALSE;
  433.     static int cnt2[10] = 0;
  434.     static int defcnt[10];
  435.  
  436.     if (been_here[ind] == FALSE)
  437.     {
  438.         been_here[ind] = TRUE;
  439.  
  440.         EG_SetAPen(rp, 0x30303000);
  441.         EG_AreaCircle(rp, x, y, 6);
  442.  
  443.         EG_SetAPen(rp, 0x40404000);
  444.         EG_AreaCircle(rp, x, y, 5);
  445.  
  446.         EG_SetAPen(rp, 0x50505000);
  447.         EG_AreaCircle(rp, x-1, y-1, 4);
  448.  
  449.         EG_SetAPen(rp, 0x60606000);
  450.         EG_AreaCircle(rp, x-1, y-1, 3);
  451.  
  452.         EG_SetAPen(rp, 0x70707000);
  453.         EG_AreaCircle(rp, x-2, y-2, 2);
  454.  
  455.         EG_SetAPen(rp, 0x8f8f8f00);
  456.         EG_AreaCircle(rp, x-3, y-3, 1);
  457.         defcnt[ind] = 0;
  458.     }
  459.  
  460.     if ( (rand() % 1024 == 42) && (defcnt[ind] == 0) )
  461.     {
  462.         EG_SetAPen(rp, 0x30303000 & 0xff000000);
  463.         EG_AreaCircle(rp, x, y, 6);
  464.  
  465.         EG_SetAPen(rp, 0x50505000 & 0xff000000);
  466.         EG_AreaCircle(rp, x, y, 5);
  467.  
  468.         EG_SetAPen(rp, 0x70707000 & 0xff000000);
  469.         EG_AreaCircle(rp, x-1, y-1, 4);
  470.  
  471.         EG_SetAPen(rp, 0x90909000 & 0xff000000);
  472.         EG_AreaCircle(rp, x-1, y-1, 3);
  473.  
  474.         EG_SetAPen(rp, 0xc0c0c000 & 0xff000000);
  475.         EG_AreaCircle(rp, x-2, y-2, 2);
  476.  
  477.         EG_SetAPen(rp, 0xffffff00 & 0xff000000);
  478.         EG_AreaCircle(rp, x-3, y-3, 1);
  479.  
  480.         defcnt[ind] = 50 + rand() % 100;
  481.     }
  482.     else
  483.     {
  484.         if (defcnt[ind] != 0)
  485.             defcnt[ind]--;
  486.         else
  487.         {
  488.             cnt2[ind]++;
  489.             if (cnt2[ind] == del)
  490.             {
  491.                 EG_SetAPen(rp, 0x30303000 & col);
  492.                 EG_AreaCircle(rp, x, y, 6);
  493.  
  494.                 EG_SetAPen(rp, 0x50505000 & col);
  495.                 EG_AreaCircle(rp, x, y, 5);
  496.  
  497.                 EG_SetAPen(rp, 0x70707000 & col);
  498.                 EG_AreaCircle(rp, x-1, y-1, 4);
  499.  
  500.                 EG_SetAPen(rp, 0x90909000 & col);
  501.                 EG_AreaCircle(rp, x-1, y-1, 3);
  502.  
  503.                 EG_SetAPen(rp, 0xc0c0c000 & col);
  504.                 EG_AreaCircle(rp, x-2, y-2, 2);
  505.  
  506.                 EG_SetAPen(rp, 0xffffff00 & col);
  507.                 EG_AreaCircle(rp, x-3, y-3, 1);
  508.             }
  509.             else if (cnt2[ind] == del * 2)
  510.             {
  511.                 cnt2[ind] = 0;
  512.  
  513.                 EG_SetAPen(rp, 0x30303000);
  514.                 EG_AreaCircle(rp, x, y, 6);
  515.  
  516.                 EG_SetAPen(rp, 0x40404000);
  517.                 EG_AreaCircle(rp, x, y, 5);
  518.  
  519.                 EG_SetAPen(rp, 0x50505000);
  520.                 EG_AreaCircle(rp, x-1, y-1, 4);
  521.  
  522.                 EG_SetAPen(rp, 0x60606000);
  523.                 EG_AreaCircle(rp, x-1, y-1, 3);
  524.  
  525.                 EG_SetAPen(rp, 0x70707000);
  526.                 EG_AreaCircle(rp, x-2, y-2, 2);
  527.  
  528.                 EG_SetAPen(rp, 0x8f8f8f00);
  529.                 EG_AreaCircle(rp, x-3, y-3, 1);
  530.             }
  531.         }
  532.     }
  533. }
  534.  
  535. /************/
  536. /* draw_zip */
  537. /************/
  538. void draw_zip(int x, int y, EG_RastPortPtr rp, int ind)
  539. {
  540.     static int been_here[10] = FALSE;
  541.     static unsigned char val[10];
  542.     static int cnt[10];
  543.     static int cnt2[10];
  544.     int i;
  545.  
  546.     if (been_here[ind] == FALSE)
  547.     {
  548.         been_here[ind] = TRUE;
  549.  
  550.         /* minimal delay 2 seconds, max 4 seconds (200 jiffies) */
  551.         cnt[ind] = 100 + rand() % 100;
  552.         cnt2[ind] = 0;
  553.         val[ind] = 0;
  554.  
  555.         for (i = 0; i < 16; i++)
  556.         {
  557.             EG_SetAPen(rp, GRAY);
  558.             EG_RectFill(rp, x + i * 16, y, 10, 2);
  559.         }
  560.      }
  561.  
  562.     if (cnt2[ind] == cnt[ind])
  563.     {
  564.         if (val[ind] > 0 && val[ind] < 17)
  565.         {
  566.             EG_SetAPen(rp, GRAY);
  567.             EG_RectFill(rp, x + (val[ind] - 1) * 16, y, 10, 2);
  568.         }
  569.         if (val[ind] < 16)
  570.         {
  571.             if (rand() % 64 == 42)
  572.                 EG_SetAPen(rp, 0xff200000);
  573.             else
  574.                 EG_SetAPen(rp, 0xffd00000);
  575.             EG_RectFill(rp, x + val[ind] * 16, y, 10, 2);
  576.         }
  577.         val[ind]++;
  578.  
  579.         if (val[ind] == 17)
  580.         {
  581.             val[ind] = 0;
  582.             cnt2[ind] = 0;
  583.             cnt[ind] = 100 + rand() % 100;
  584.         }
  585.     }
  586.     else
  587.         cnt2[ind]++;
  588. }
  589.  
  590.  
  591. /*************/
  592. /* draw_bars */
  593. /*************/
  594. void draw_bars(int x, int y, EG_RastPortPtr rp, int ind)
  595. {
  596.     static int been_here[20] = FALSE;
  597.     static int new_val[20], cur_val[20];
  598.     int step, diff;
  599.     int r, g, b;
  600.  
  601.     if (been_here[ind] == FALSE)
  602.     {
  603.         been_here[ind] = TRUE;
  604.  
  605.         EG_SetAPen(rp, GRAY);
  606.         EG_RectFill(rp, x, y, 200, 5);
  607.  
  608.         new_val[ind] = rand() % 200;
  609.         cur_val[ind] = 0;
  610.     }
  611.  
  612.     diff = abs(new_val[ind] - cur_val[ind]);
  613.     if (diff > 20)
  614.         step = 8;
  615.     else if (diff > 10)
  616.         step = 4;
  617.     else if (diff > 5)
  618.         step = 3;
  619.     else
  620.         step = 1;
  621.  
  622.     if (cur_val[ind] > new_val[ind])
  623.         step = -step;
  624.  
  625.     cur_val[ind] += step;
  626.  
  627.     if (cur_val[ind] == new_val[ind])
  628.         new_val[ind] = rand() % 200;
  629.  
  630.  
  631.     /* critical values - remove green */
  632.     if (cur_val[ind] > 150)
  633.     {
  634.         r = 0xff - ((cur_val[ind] - 150) * 4);
  635.         g = 0xd0 - ((cur_val[ind] - 150) * 2);
  636.         b = 0x00 + ((cur_val[ind] - 150) * 5);
  637.         EG_SetAPen(rp, r << 24 | g << 16 | b << 8);
  638.     }
  639.     else
  640.         EG_SetAPen(rp, 0xffd00000);
  641.  
  642.     EG_RectFill(rp, x, y, cur_val[ind], 5);
  643.     EG_SetAPen(rp, GRAY);
  644.     EG_RectFill(rp, x + cur_val[ind], y, 200 - cur_val[ind], 5);
  645. }
  646.  
  647.  
  648.  
  649. /**************/
  650. /* draw_vbars */
  651. /**************/
  652. void draw_vbars(int x, int y, EG_RastPortPtr rp, int ind)
  653. {
  654.     static int been_here[20] = FALSE;
  655.     static int new_val[20], cur_val[20];
  656.     int step, diff, g;
  657.  
  658.     if (been_here[ind] == FALSE)
  659.     {
  660.         been_here[ind] = TRUE;
  661.  
  662.         EG_SetAPen(rp, GRAY);
  663.         EG_RectFill(rp, x, y, 8, 100);
  664.  
  665.         new_val[ind] = rand() % 100;
  666.         cur_val[ind] = 0;
  667.     }
  668.  
  669.     diff = abs(new_val[ind] - cur_val[ind]);
  670.     if (diff > 20)
  671.         step = 8;
  672.     else if (diff > 10)
  673.         step = 4;
  674.     else if (diff > 5)
  675.         step = 3;
  676.     else
  677.         step = 1;
  678.  
  679.     if (cur_val[ind] > new_val[ind])
  680.         step = -step;
  681.  
  682.     cur_val[ind] += step;
  683.  
  684.     if (cur_val[ind] == new_val[ind])
  685.         new_val[ind] = rand() % 100;
  686.  
  687.     /* critical values - remove green */
  688.     if (cur_val[ind] < 40)
  689.     {
  690.         g = 0xd0 - ((40 - cur_val[ind]) * 4);
  691.         EG_SetAPen(rp, 0xff000000 | g << 16);
  692.     }
  693.     else
  694.         EG_SetAPen(rp, 0xffd00000);
  695.  
  696.     EG_RectFill(rp, x, y + cur_val[ind], 8, 100 - cur_val[ind]);
  697.     EG_SetAPen(rp, GRAY);
  698.     EG_RectFill(rp, x, y, 8, cur_val[ind]);
  699. }
  700.  
  701.  
  702. /************/
  703. /* draw_ekg */
  704. /************/
  705. void draw_ekg(int x, int y, EG_RastPortPtr rp, int ind)
  706. {
  707.     static int been_here[20] = FALSE;
  708.     static int red_val[20], grn_val[20], grn_dir[20], oldgrn[20], real_grn[20];
  709.     int xp;
  710.  
  711.     if (been_here[ind] == FALSE)
  712.     {
  713.         been_here[ind] = TRUE;
  714.  
  715.         EG_SetAPen(rp, GRAY);
  716.         EG_Move(rp, x, y);
  717.         EG_Draw(rp, x + 31, y);
  718.         EG_Draw(rp, x + 31, y + 31);
  719.         EG_Draw(rp, x, y + 31);
  720.         EG_Draw(rp, x, y);
  721.         grn_val[ind] = 15;
  722.         grn_dir[ind] = 1;
  723.         oldgrn[ind] = 15;
  724.     }
  725.  
  726.     red_val[ind]++;
  727.     if (red_val[ind] > 17)
  728.     {
  729.         xp = 5 + rand() % 2;
  730.     }
  731.     else
  732.     {
  733.         xp = 25 + rand() % 2;
  734.     }
  735.     if (red_val[ind] == 34)
  736.         red_val[ind] = 0;
  737.  
  738.     EG_SetAPen(rp, 0xff000000);
  739.     if (red_val[ind] == 0 || red_val[ind] == 17)
  740.     {
  741.         EG_Move(rp, x + 5, y + 29);
  742.         EG_Draw(rp, x + 25, y + 29);
  743.     }
  744.     EG_WritePixel(rp, x + xp, y + 29);
  745.  
  746.     grn_val[ind] += grn_dir[ind];
  747.     if (grn_val[ind] == 25)
  748.     {
  749.         grn_val[ind] = 24;
  750.         grn_dir[ind] = -1;
  751.     }
  752.     else if (grn_val[ind] == 4)
  753.     {
  754.         grn_val[ind] = 5;
  755.         grn_dir[ind] = 1;
  756.     }
  757.     real_grn[ind] = grn_val[ind] + rand() % 5;
  758.     EG_SetAPen(rp, 0xffd00000);
  759.     EG_Move(rp, x + oldgrn[ind], y + 28);
  760.     EG_Draw(rp, x + real_grn[ind], y + 29);
  761.  
  762.     oldgrn[ind] = real_grn[ind];
  763.  
  764. //    EG_WritePixel(rp, x + grn_val[ind] + rand() % 3, y + 29);
  765.  
  766. /*
  767.     xp = rand() % 30;
  768.     yp = rand() % 29;
  769.     EG_WritePixel(rp, x + xp + 1, y + yp + 1);
  770. */
  771.  
  772.     EG_ScrollRasterNoClear(rp, x + 1, y + 1, 30, 30, 0, 1);
  773. }
  774.  
  775.  
  776. /*****************************************/
  777. /* draw_pix - draws various small images */
  778. /*****************************************/
  779. void draw_pix(int x, int y, EG_RastPortPtr rp)
  780. {
  781.     static int been_here = FALSE;
  782.     static int num = 0, delay = 0, del2 = 0, noise = 0;
  783.  
  784.     if (been_here == FALSE)
  785.     {
  786.         been_here = TRUE;
  787.  
  788.         EG_SetAPen(rp, GRAY);
  789.         EG_Move(rp, x, y);
  790.         EG_Draw(rp, x + 31, y);
  791.         EG_Draw(rp, x + 31, y + 31);
  792.         EG_Draw(rp, x, y + 31);
  793.         EG_Draw(rp, x, y);
  794.         /* min delay 2 seconds, max 4 seconds */
  795.         delay = rand() % 100 + 100;
  796.     }
  797.  
  798.     if (delay)
  799.     {
  800.         delay--;
  801.         noise++;
  802.         if (noise == 8)
  803.             noise = 0;
  804.         EG_CopyBitMapRastPort(pixmaps[noise], rp, 0, 0, IMG_WIDTH, IMG_HEIGHT, x + 1, y + 1);
  805.     }
  806.     else
  807.     {
  808.         if (del2 == 0)
  809.         {
  810.             del2 = rand() % 50 + 50;
  811.             num = rand() % 8 + 8;
  812.             EG_CopyBitMapRastPort(pixmaps[num], rp, 0, 0, IMG_WIDTH, IMG_HEIGHT, x + 1, y + 1);
  813.         }
  814.  
  815.         del2--;
  816.         if (del2 == 0)
  817.             delay = rand() % 100 + 100;
  818.         /* the next time this function is called, we are automatically placed */
  819.         /* in the upper part of the if when delay was set to a new value here */
  820.     }
  821. }
  822.  
  823.  
  824. /**************************************************/
  825. /* crash function - frees all allocated resources */
  826. /**************************************************/
  827. void crash(char * string)
  828. {
  829.     int i;
  830.  
  831.     for (i = 0; i < 16; i++)
  832.     {
  833.         if (pixmaps[i])
  834.             E_DisposeBitMapFrame(pixmaps[i]);
  835.     }
  836.  
  837.     if (mapclass)
  838.         E_ReleaseClass(mapclass);
  839.  
  840.     if (my_window)
  841.         EI_CloseWindow(my_window);
  842.  
  843.     if (EGSGfxBase != NULL)
  844.         CloseLibrary(EGSGfxBase);
  845.  
  846.     if (EGSIntuiBase != NULL)
  847.         CloseLibrary(EGSIntuiBase);
  848.  
  849.     if (EGSBase != NULL)
  850.         CloseLibrary(EGSBase);
  851.  
  852.     if (NULL == string)
  853.         exit (0);
  854.     else
  855.     {
  856.         printf ("%s.\n", string);
  857.         exit (10);
  858.     }
  859. }
  860.  
  861.